
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import plotly.express as px
import plotly.io as pio
pio.renderers.default = "notebook_connected"
print("All Libraries Loaded Successfully")

All Libraries Loaded Successfully


df = pd.read_csv("C:/Users/rohan/OneDrive/Desktop/MBA/Term 4/O712/Group Project/O712 Group Project Data - eCommerce Customers.csv")
# Visualizing the top few rows for confirming successful load of the raw data
df.head(7)


df.tail(6)


df.shape

(12330, 13)


df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 12330 entries, 0 to 12329
Data columns (total 13 columns):
 #   Column                   Non-Null Count  Dtype  
---  ------                   --------------  -----  
 0   Administrative           12330 non-null  int64  
 1   Administrative_Duration  12330 non-null  float64
 2   Informational            12330 non-null  int64  
 3   Informational_Duration   12330 non-null  float64
 4   ProductRelated           12330 non-null  int64  
 5   ProductRelated_Duration  12330 non-null  float64
 6   BounceRates              12330 non-null  float64
 7   ExitRates                12330 non-null  float64
 8   PageValues               12330 non-null  float64
 9   SpecialDay               12330 non-null  float64
 10  VisitorType              12330 non-null  object 
 11  Weekend                  12330 non-null  bool   
 12  Transaction              12330 non-null  object 
dtypes: bool(1), float64(7), int64(3), object(2)
memory usage: 1.1+ MB


df.duplicated().sum()

710


df.describe()


df['VisitorType Status'] = (pd.get_dummies(df['VisitorType'])).iloc[:,1]
df['Weekend Status'] = (pd.get_dummies(df['Weekend'])).iloc[:,1]
df['Transaction Status'] = (pd.get_dummies(df['Transaction'])).iloc[:,1]


df.head()


df.shape

(12330, 16)


df.corr()

C:\Users\rohan\AppData\Local\Temp\ipykernel_24048\1134722465.py:1: FutureWarning:

The default value of numeric_only in DataFrame.corr is deprecated. In a future version, it will default to False. Select only valid columns or specify the value of numeric_only to silence this warning.


import seaborn as sns
plt.figure(figsize=(10,10))
sns.heatmap(df.corr(), annot = True, cmap = 'RdBu',fmt =".2f",vmin=-1)
plt.show()

C:\Users\rohan\AppData\Local\Temp\ipykernel_24048\3845839996.py:3: FutureWarning:

The default value of numeric_only in DataFrame.corr is deprecated. In a future version, it will default to False. Select only valid columns or specify the value of numeric_only to silence this warning.


fig = px.box(df, y="PageValues")
fig.show()


fig = px.box(df, y="ExitRates")
fig.show() 

px.histogram(df, x="ExitRates",nbins=100)


fig = px.box(df, y="ProductRelated")
fig.show()


df["Transaction"].value_counts()

No     10422
Yes     1908
Name: Transaction, dtype: int64


table0 = pd.pivot_table(df,index=["Transaction"],values="Transaction Status",aggfunc="count")
table0.reset_index(inplace=True)
table0


table2 = pd.pivot_table(df,index=["Weekend"],values="Transaction Status",aggfunc="count")
table2.reset_index(inplace=True)
table2


table3 = pd.pivot_table(df,index=["Weekend","Transaction"],values="Transaction Status",aggfunc="count")
table3.reset_index(inplace=True)
table3


fig = px.bar(data_frame=table3,x="Transaction",y="Transaction Status",color="Weekend",barmode="group",text="Transaction Status",
             title="Number of Visitors By Transaction Status & Weekend",height=650,
            labels={"Transaction Status":"Number of Visitors"})
fig["data"]
fig["data"][0]["textposition"] = "outside"
fig["data"][1]["textposition"] = "outside"
fig["data"][0]["marker"]["color"] = "#2BB876"
fig["data"][1]["marker"]["color"] = "#9b287b"
# fig["data"]
fig.show()


table1 = pd.pivot_table(df,index=["VisitorType"],values="VisitorType Status",aggfunc="count")
table1.reset_index(inplace=True)
table1


table4 = pd.pivot_table(df,index=["Transaction","VisitorType"],values="Transaction Status",aggfunc="count")
table4.reset_index(inplace=True)
table4


fig = px.bar(data_frame=table4,x="VisitorType",y="Transaction Status",color="Transaction",barmode="group",text="Transaction Status",
             title="Number of Visitors By Transaction Status & Visitor Type",height=650,
            labels={"Transaction Status":"Number of Visitors"})
fig["data"]
fig["data"][0]["textposition"] = "outside"
fig["data"][1]["textposition"] = "outside"
fig["data"][0]["marker"]["color"] = "#223C50"
fig["data"][1]["marker"]["color"] = "#4CA334"
# fig["data"]
fig.show()


table5 = pd.pivot_table(df,index=["Transaction","VisitorType","Weekend"],values="Transaction Status",aggfunc="count")
table5.reset_index(inplace=True)
table5


fig = px.bar(data_frame=table5,x="VisitorType",y="Transaction Status",color="Transaction",barmode="group",text="Transaction Status",
             title="Number of Visitors By Transaction Status & Visitor Type Differentiated by Weekend",height=650,facet_col="Weekend",
            labels={"Transaction Status":"Number of Visitors"})
fig["data"]
fig["data"][0]["textposition"] = "outside"
fig["data"][1]["textposition"] = "outside"
fig["data"][2]["textposition"] = "outside"
fig["data"][3]["textposition"] = "outside"

fig["data"][0]["marker"]["color"] = "#223C50"
fig["data"][1]["marker"]["color"] = "#223C50"
# fig["data"]
fig.show()


sns.relplot(data=df,x="SpecialDay",y="ProductRelated_Duration",hue="Transaction",col="Transaction",kind="line")
plt.show()


sns.relplot(data=df,x="SpecialDay",y="PageValues",hue="Transaction",col="VisitorType",kind="line")
plt.show()


sns.lmplot(data=df,x="PageValues",y="Transaction Status",col="VisitorType",facet_kws=dict(sharex=False, sharey=False),logistic=True)
plt.show()


sns.lmplot(data=df,x="PageValues",y="Transaction Status",col="Weekend",facet_kws=dict(sharex=False, sharey=False),logistic=True)
plt.show()


import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import plotly.express as px
import plotly.io as pio
pio.renderers.default = "notebook_connected"
print("All Libraries Loaded Successfully")

All Libraries Loaded Successfully


df = pd.read_csv("Clifford_Clean with Duplicates.csv")
df.head()


df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 12330 entries, 0 to 12329
Data columns (total 16 columns):
 #   Column                   Non-Null Count  Dtype  
---  ------                   --------------  -----  
 0   Administrative           12330 non-null  int64  
 1   Administrative_Duration  12330 non-null  float64
 2   Informational            12330 non-null  int64  
 3   Informational_Duration   12330 non-null  float64
 4   ProductRelated           12330 non-null  int64  
 5   ProductRelated_Duration  12330 non-null  float64
 6   BounceRates              12330 non-null  float64
 7   ExitRates                12330 non-null  float64
 8   PageValues               12330 non-null  float64
 9   SpecialDay               12330 non-null  float64
 10  VisitorType              12330 non-null  object 
 11  Weekend                  12330 non-null  bool   
 12  Transaction              12330 non-null  object 
 13  VisitorType Status       12330 non-null  int64  
 14  Weekend Status           12330 non-null  int64  
 15  Transaction Status       12330 non-null  int64  
dtypes: bool(1), float64(7), int64(6), object(2)
memory usage: 1.4+ MB


plt.figure(figsize=(10,10))
sns.heatmap(df.corr(), annot = True, cmap = 'RdBu',fmt =".2f",vmin=-1)

C:\Users\rohan\AppData\Local\Temp\ipykernel_24048\3420667235.py:2: FutureWarning:

The default value of numeric_only in DataFrame.corr is deprecated. In a future version, it will default to False. Select only valid columns or specify the value of numeric_only to silence this warning.

<Axes: >


col = ['Administrative', 'Administrative_Duration', 'Informational',
       'Informational_Duration', 'ProductRelated', 'ProductRelated_Duration',
       'BounceRates', 'ExitRates', 'PageValues', 'SpecialDay',  'VisitorType Status', 'Weekend Status',
       'Transaction Status','VisitorType',
       'Weekend', 'Transaction',]
df= df[col]
df.head()


from sklearn.linear_model import LogisticRegression 
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import normalize
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
import statsmodels.api as sm
import statsmodels.formula.api as smf
from sklearn.metrics import roc_curve, roc_auc_score,classification_report,confusion_matrix,accuracy_score
from sklearn.cluster import KMeans
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.tree import plot_tree


X = df.iloc[:,0:12]
Y = df.iloc[:,12]
Xtrain, Xtest, ytrain, ytest = train_test_split(X,Y, test_size = 0.2, random_state = 42)
Xtrain.head()


ytrain.head()

1785     0
10407    0
286      0
6520     0
12251    0
Name: Transaction Status, dtype: int64


log_reg_full = LogisticRegression()


log_reg_full.fit(Xtrain, ytrain)

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\linear_model\_logistic.py:460: ConvergenceWarning:

lbfgs failed to converge (status=1):
STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.

Increase the number of iterations (max_iter) or scale the data as shown in:
    https://scikit-learn.org/stable/modules/preprocessing.html
Please also refer to the documentation for alternative solver options:
    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression

LogisticRegression()

LogisticRegression()


ytrain_predicted_full_log = log_reg_full.predict(Xtrain)
ytrain_predicted_prob_full_log = log_reg_full.predict_proba(Xtrain)
ytest_predicted_full_log = log_reg_full.predict(Xtest)
ytest_predicted_prob_full_log = log_reg_full.predict_proba(Xtest)

print("Accuracy Score (train):", accuracy_score(y_pred=ytrain_predicted_full_log,y_true= ytrain))
print("Accuracy Score (test):",accuracy_score(y_pred=ytest_predicted_full_log,y_true= ytest))

Accuracy Score (train): 0.8871654501216545
Accuracy Score (test): 0.8718572587185726


sns.heatmap(confusion_matrix(ytest, ytest_predicted_full_log), annot = True,  fmt = 'g')
plt.xlabel('Predicted Values') 
plt.ylabel('Actual Values')
plt.title("Confusion Matrix for Full Scale Log R Model")
plt.show()


TP_full = confusion_matrix(ytest, ytest_predicted_full_log)[1,1]
TN_full =confusion_matrix(ytest, ytest_predicted_full_log)[0,0]
FP_full = confusion_matrix(ytest, ytest_predicted_full_log)[0,1]
FN_full = confusion_matrix(ytest, ytest_predicted_full_log)[1,0]


(TP_full + TN_full )/ (TP_full + TN_full +FP_full +FN_full)

0.8718572587185726


print(classification_report(ytest, ytest_predicted_full_log))

              precision    recall  f1-score   support

           0       0.88      0.98      0.93      2055
           1       0.74      0.36      0.48       411

    accuracy                           0.87      2466
   macro avg       0.81      0.67      0.70      2466
weighted avg       0.86      0.87      0.85      2466


fpr_full_log,tpr_full_log, threshold_full_log = roc_curve(ytest,log_reg_full.predict_proba(Xtest)[:,1])
import matplotlib.pyplot as plt
plt.plot(fpr_full_log,tpr_full_log,label="FPR vs TPR")
plt.plot([0,1], [0,1], linestyle='--', label='No Skill')
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve for Full Scale Log Model")
plt.legend()
plt.show()


roc_auc_score(ytest,ytest_predicted_full_log)

0.6652068126520682


scaler = StandardScaler() # Create a scaler object
scaler.fit(Xtrain)       # using the fit function I will provide the base mean and standard deviation to the object
XtrainScaled = scaler.transform(Xtrain) # Now the values for the Xtrain has been scaled


XtestScaled = scaler.transform(Xtest) # Now the values for the Xtest has been scaled


# Create the object of the KNeighboursClassifier with the 
knn_full = KNeighborsClassifier(n_neighbors=2)
knn_full

KNeighborsClassifier(n_neighbors=2)

KNeighborsClassifier(n_neighbors=2)


knn_full.fit(XtrainScaled,ytrain)

KNeighborsClassifier(n_neighbors=2)

KNeighborsClassifier(n_neighbors=2)


ytrainPredicted_knn_full = knn_full.predict(XtrainScaled) # Store the predictions from the model on the train dataset
ytestPredicted_knn_full = knn_full.predict(XtestScaled) # Store the predictions from the model on the test dataset


print("Accuracy Score (train):", accuracy_score(y_pred=ytrainPredicted_knn_full,y_true= ytrain))
print("Accuracy Score (test):",accuracy_score(y_pred=ytestPredicted_knn_full,y_true= ytest))

Accuracy Score (train): 0.9283252230332523
Accuracy Score (test): 0.8718572587185726


Accuracy_dict_knn_full = {
    "N":[],
    "train_acc" : [],
    "test_acc" :[]
}
accuracy_df_knn_full=pd.DataFrame(Accuracy_dict_knn_full)
accuracy_df_knn_full


for i in range(1,50):
    new_row = []
    knn_full_ = KNeighborsClassifier(n_neighbors=i)
    knn_full_.fit(XtrainScaled,ytrain)
    ytrainPredicted_knn_full__ = knn_full_.predict(XtrainScaled) # Store the predictions from the model on the train dataset
    ytestPredicted_knn_full__ = knn_full_.predict(XtestScaled) # Store the predictions from the model on the test dataset
    new_row.append(i)
    new_row.append(accuracy_score(y_true=ytrain,y_pred=ytrainPredicted_knn_full__))
    new_row.append(accuracy_score(y_true=ytest,y_pred=ytestPredicted_knn_full__))
    accuracy_df_knn_full.loc[len(accuracy_df_knn_full)] = new_row
    
accuracy_df_knn_full.head()


fig = px.line(x = accuracy_df_knn_full["N"],y=[accuracy_df_knn_full["train_acc"],accuracy_df_knn_full['test_acc']],labels={"variable":"Accuracy Type","value":"Accuracy"})
fig["data"][0]["name"] ="Train Accuracy"
fig["data"][1]["name"] ="Test Accuracy"
fig.show()


knn_full_final = KNeighborsClassifier(n_neighbors=24)
knn_full_final.fit(XtrainScaled,ytrain)
ytestPredicted_knn_full_final = knn_full_final.predict(XtestScaled)


accuracy_score(y_true=ytest,y_pred=ytestPredicted_knn_full_final)*100

87.87510137875101


confusion_matrix(y_true=ytest,y_pred=ytestPredicted_knn_full_final)

array([[2009,   46],
       [ 253,  158]], dtype=int64)


sns.heatmap(confusion_matrix(y_true=ytest,y_pred=ytestPredicted_knn_full_final),annot=True,fmt='g')
plt.xlabel("Predictions")
plt.ylabel("Actual Values")
plt.title("Confusion Matrix for Full KNN Model")
plt.show()


TP_knn_full_final = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_knn_full_final)[1,1]
TN_knn_full_final =confusion_matrix(y_true=ytest,y_pred=ytestPredicted_knn_full_final)[0,0]
FP_knn_full_final = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_knn_full_final)[0,1]
FN_knn_full_final = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_knn_full_final)[1,0]


(TP_knn_full_final + TN_knn_full_final )/ (TP_knn_full_final + TN_knn_full_final +FP_knn_full_final +FN_knn_full_final)

0.8787510137875101


print(classification_report(ytest,ytestPredicted_knn_full_final))

              precision    recall  f1-score   support

           0       0.89      0.98      0.93      2055
           1       0.77      0.38      0.51       411

    accuracy                           0.88      2466
   macro avg       0.83      0.68      0.72      2466
weighted avg       0.87      0.88      0.86      2466


fpr_knn_full_final,tpr_knn_full_final, threshold_knn_full_final = roc_curve(ytest,knn_full_final.predict_proba(XtestScaled)[:,1])
import matplotlib.pyplot as plt
plt.plot(fpr_knn_full_final,tpr_knn_full_final,label="FPR vs TPR")
plt.plot([0,1], [0,1], linestyle='--', label='No Skill')
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve for Full Scale BEST-K KNN Model")
plt.legend()
plt.show()


roc_auc_score(ytest,ytestPredicted_knn_full_final)

0.681021897810219


full_dt = DecisionTreeClassifier()
full_dt.fit(Xtrain,ytrain)
full_dt

DecisionTreeClassifier()

DecisionTreeClassifier()


yTrainPredicted_full_dt =  full_dt.predict(Xtrain)
yTestPredicted_full_dt =  full_dt.predict(Xtest)

yTrainPredicted_full_dt.size,yTestPredicted_full_dt.size

(9864, 2466)


print("Accuracy Score (train):", accuracy_score(y_pred=yTrainPredicted_full_dt,y_true= ytrain))
print("Accuracy Score (test):",accuracy_score(y_pred=yTestPredicted_full_dt,y_true= ytest))

Accuracy Score (train): 0.9996958637469586
Accuracy Score (test): 0.8552311435523114


plt.figure(figsize=(20,15))
plot_tree(full_dt)
plt.show()


Accuracy_dict_DT = {
    "N":[],
    "train_acc" : [],
    "test_acc" :[]
}
accuracy_df_full_dt=pd.DataFrame(Accuracy_dict_DT)
accuracy_df_full_dt


for i in range(1,20):
    new_row=[]
    dt_full_dt = DecisionTreeClassifier(random_state=1,max_depth=i)
    dt_full_dt.fit(Xtrain,ytrain)
    yTrainPredicted_full_dt_ =  dt_full_dt.predict(Xtrain)
    yTestPredicted_full_dt_ =  dt_full_dt.predict(Xtest)
    new_row.append(i)
    new_row.append(accuracy_score(y_true=ytrain,y_pred=yTrainPredicted_full_dt_))
    new_row.append(accuracy_score(y_true=ytest,y_pred=yTestPredicted_full_dt_))
    accuracy_df_full_dt.loc[len(accuracy_df_full_dt)] = new_row
accuracy_df_full_dt.head()


import plotly.express as px
fig = px.line(x = accuracy_df_full_dt["N"],y=[accuracy_df_full_dt["train_acc"],accuracy_df_full_dt['test_acc']])
fig["data"][0]["name"] ="Train Accuracy"
fig["data"][1]["name"] ="Test Accuracy"
fig.show()


dt_full_final = DecisionTreeClassifier(random_state=1,max_depth=4)
dt_full_final.fit(Xtrain,ytrain)
yTrainPredicted_dt_full_final =  dt_full_final.predict(Xtrain)
yTestPredicted_dt_full_final =  dt_full_final.predict(Xtest)


plt.figure(figsize=(50,25))
plot_tree(dt_full_final,feature_names=list(Xtrain.columns),filled=True,class_names=["NO Transaction","YES Transaction"],fontsize=18)
plt.show()


confusion_matrix(y_true=ytest,y_pred=yTestPredicted_dt_full_final)

array([[1972,   83],
       [ 208,  203]], dtype=int64)


sns.heatmap(confusion_matrix(y_true=ytest,y_pred=yTestPredicted_dt_full_final),annot=True,fmt="g")
plt.xlabel("Prediction Values")
plt.ylabel("Actual Values")
plt.title("Confusion Matrix for Full Decision Tree")
plt.show()


TP_full_dt = confusion_matrix(y_true=ytest,y_pred=yTestPredicted_dt_full_final)[1,1]
TN_full_dt =confusion_matrix(y_true=ytest,y_pred=yTestPredicted_dt_full_final)[0,0]
FP_full_dt = confusion_matrix(y_true=ytest,y_pred=yTestPredicted_dt_full_final)[0,1]
FN_full_dt = confusion_matrix(y_true=ytest,y_pred=yTestPredicted_dt_full_final)[1,0]


(TP_full_dt + TN_full_dt )/ (TP_full_dt + TN_full_dt +FP_full_dt +FN_full_dt)

0.8819951338199513


print(classification_report(y_true=ytest,y_pred=yTestPredicted_dt_full_final))

              precision    recall  f1-score   support

           0       0.90      0.96      0.93      2055
           1       0.71      0.49      0.58       411

    accuracy                           0.88      2466
   macro avg       0.81      0.73      0.76      2466
weighted avg       0.87      0.88      0.87      2466


dt_full_final.feature_importances_

array([0.03170617, 0.00592976, 0.        , 0.00097663, 0.0093989 ,
       0.00875109, 0.08719713, 0.00752461, 0.8485157 , 0.        ,
       0.        , 0.        ])


pd.DataFrame({
    "Feature":Xtrain.columns,
    "Importance":dt_full_final.feature_importances_
})


fpr_full_dt,tpr_full_dt, threshold_full_dt = roc_curve(ytest,dt_full_final.predict_proba(Xtest)[:,1])
plt.plot(fpr_full_dt,tpr_full_dt,label="FPR vs TPR")
plt.plot([0,1], [0,1], linestyle='--', label='No Skill')
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve for Full Scale Decision Tree")
plt.legend()
plt.show()


roc_auc_score(ytest,yTestPredicted_dt_full_final)

0.7267639902676399


log_reg_model = sm.GLM(ytrain, sm.add_constant(Xtrain), family=sm.families.Binomial()).fit()
log_reg_model.summary()


XtrainR = Xtrain.drop(columns = ['Administrative','Informational_Duration','Administrative_Duration', 'BounceRates',"Weekend Status"])
XtestR = Xtest.drop(columns = ['Administrative','Informational_Duration','Administrative_Duration', 'BounceRates',"Weekend Status"])
XtrainR.head()


XtestR.head()


reduced_logR = LogisticRegression()


reduced_logR.fit(XtrainR, ytrain)

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\linear_model\_logistic.py:460: ConvergenceWarning:

lbfgs failed to converge (status=1):
STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.

Increase the number of iterations (max_iter) or scale the data as shown in:
    https://scikit-learn.org/stable/modules/preprocessing.html
Please also refer to the documentation for alternative solver options:
    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression

LogisticRegression()

LogisticRegression()


ytrain_predicted_reduced_logR = reduced_logR.predict(XtrainR)
ytrain_predicted_prob_reduced_logR = reduced_logR.predict_proba(XtrainR)
ytest_predicted_reduced_logR = reduced_logR.predict(XtestR)
ytest_predicted_prob_reduced_logR = reduced_logR.predict_proba(XtestR)

print("Accuracy Score (train):", accuracy_score(y_pred=ytrain_predicted_reduced_logR,y_true= ytrain))
print("Accuracy Score (test):",accuracy_score(y_pred=ytest_predicted_reduced_logR,y_true= ytest))

Accuracy Score (train): 0.889294403892944
Accuracy Score (test): 0.8690186536901865


sns.heatmap(confusion_matrix(ytest, ytest_predicted_reduced_logR), annot = True,  fmt = 'g')
plt.xlabel('Predicted Values') 
plt.ylabel('Actual Values')
plt.title("Confusion Matrix for Reduced Log R Model")
plt.show()


TP_reduced_logR = confusion_matrix(ytest, ytest_predicted_reduced_logR)[1,1]
TN_reduced_logR =confusion_matrix(ytest, ytest_predicted_reduced_logR)[0,0]
FP_reduced_logR = confusion_matrix(ytest, ytest_predicted_reduced_logR)[0,1]
FN_reduced_logR = confusion_matrix(ytest, ytest_predicted_reduced_logR)[1,0]


(TP_reduced_logR + TN_reduced_logR )/ (TP_reduced_logR + TN_reduced_logR +FP_reduced_logR +FN_reduced_logR)

0.8690186536901865


print(classification_report(ytest, ytest_predicted_reduced_logR))

              precision    recall  f1-score   support

           0       0.88      0.97      0.93      2055
           1       0.72      0.35      0.47       411

    accuracy                           0.87      2466
   macro avg       0.80      0.66      0.70      2466
weighted avg       0.86      0.87      0.85      2466


fpr_reduced_logR,tpr_reduced_logR, threshold_reduced_logR = roc_curve(ytest,reduced_logR.predict_proba(XtestR)[:,1])
import matplotlib.pyplot as plt
plt.plot(fpr_reduced_logR,tpr_reduced_logR,label="FPR vs TPR")
plt.plot([0,1], [0,1], linestyle='--', label='No Skill')
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve for Reduced Log Model")
plt.legend()
plt.show()


roc_auc_score(ytest,ytest_predicted_reduced_logR)

0.6605839416058393


scaler_knn = StandardScaler() # Create a scaler object
scaler_knn.fit(XtrainR)       # using the fit function I will provide the base mean and standard deviation to the object
XtrainScaledR = scaler_knn.transform(XtrainR) # Now the values for the XtrainR has been scaled


XtestScaledR = scaler_knn.transform(XtestR) # Now the values for the XtestR has been scaled


# Create the object of the KNeighboursClassifier with the 
reduced_knn = KNeighborsClassifier(n_neighbors=2)
reduced_knn

KNeighborsClassifier(n_neighbors=2)

KNeighborsClassifier(n_neighbors=2)


reduced_knn.fit(XtrainScaledR,ytrain)

KNeighborsClassifier(n_neighbors=2)

KNeighborsClassifier(n_neighbors=2)


ytrainPredicted_reduced_knn = reduced_knn.predict(XtrainScaledR) # Store the predictions from the model on the train dataset
ytestPredicted_reduced_knn = reduced_knn.predict(XtestScaledR) # Store the predictions from the model on the test dataset


print("Accuracy Score (train):", accuracy_score(y_pred=ytrainPredicted_reduced_knn,y_true= ytrain))
print("Accuracy Score (test):",accuracy_score(y_pred=ytestPredicted_reduced_knn,y_true= ytest))

Accuracy Score (train): 0.9274128142741281
Accuracy Score (test): 0.8653690186536902


Accuracy_dict_reduced_knn = {
    "N":[],
    "train_acc" : [],
    "test_acc" :[]
}
accuracy_df_reduced_knn=pd.DataFrame(Accuracy_dict_reduced_knn)
accuracy_df_reduced_knn


for i in range(1,50):
    new_row = []
    reduced_knn_ = KNeighborsClassifier(n_neighbors=i)
    reduced_knn_.fit(XtrainScaled,ytrain)
    ytrainPredicted_reduced_knn_ = reduced_knn_.predict(XtrainScaled) # Store the predictions from the model on the train dataset
    ytestPredicted_reduced_knn_ = reduced_knn_.predict(XtestScaled) # Store the predictions from the model on the test dataset
    new_row.append(i)
    new_row.append(accuracy_score(y_true=ytrain,y_pred=ytrainPredicted_reduced_knn_))
    new_row.append(accuracy_score(y_true=ytest,y_pred=ytestPredicted_reduced_knn_))
    accuracy_df_reduced_knn.loc[len(accuracy_df_reduced_knn)] = new_row
    
accuracy_df_reduced_knn.head()


fig = px.line(x = accuracy_df_reduced_knn["N"],y=[accuracy_df_reduced_knn["train_acc"],accuracy_df_reduced_knn['test_acc']],labels={"variable":"Accuracy Type","value":"Accuracy"})
fig["data"][0]["name"] ="Train Accuracy"
fig["data"][1]["name"] ="Test Accuracy"
fig.show()


reduced_knn_final = KNeighborsClassifier(n_neighbors=11)
reduced_knn_final.fit(XtrainScaledR,ytrain)
ytestPredicted_reduced_knn_final = reduced_knn_final.predict(XtestScaledR)


accuracy_score(y_true=ytest,y_pred=ytestPredicted_reduced_knn_final)*100

87.87510137875101


confusion_matrix(y_true=ytest,y_pred=ytestPredicted_reduced_knn_final)

array([[1973,   82],
       [ 217,  194]], dtype=int64)


sns.heatmap(confusion_matrix(y_true=ytest,y_pred=ytestPredicted_reduced_knn_final),annot=True,fmt='g')
plt.xlabel("Predictions")
plt.ylabel("Actual Values")
plt.title("Confusion Matrix for Reduced KNN Model")
plt.show()


TP_reduced_knn_final = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_reduced_knn_final)[1,1]
TN_reduced_knn_final =confusion_matrix(y_true=ytest,y_pred=ytestPredicted_reduced_knn_final)[0,0]
FP_reduced_knn_final = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_reduced_knn_final)[0,1]
FN_reduced_knn_final = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_reduced_knn_final)[1,0]


(TP_reduced_knn_final + TN_reduced_knn_final )/ (TP_reduced_knn_final + TN_knn_full_final +FP_reduced_knn_final +FN_reduced_knn_final)

0.8661071143085531


print(classification_report(ytest,ytestPredicted_reduced_knn_final))

              precision    recall  f1-score   support

           0       0.90      0.96      0.93      2055
           1       0.70      0.47      0.56       411

    accuracy                           0.88      2466
   macro avg       0.80      0.72      0.75      2466
weighted avg       0.87      0.88      0.87      2466


fpr_reduced_knn_final,tpr_reduced_knn_final, threshold_reduced_knn_final = roc_curve(ytest,reduced_knn_final.predict_proba(XtestScaledR)[:,1])
import matplotlib.pyplot as plt
plt.plot(fpr_reduced_knn_final,tpr_reduced_knn_final,label="FPR vs TPR")
plt.plot([0,1], [0,1], linestyle='--', label='No Skill')
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve for Reduced BEST-K KNN Log Model")
plt.legend()
plt.show()


roc_auc_score(ytest,ytestPredicted_reduced_knn_final)

0.7160583941605839


reduced_dt = DecisionTreeClassifier()
reduced_dt.fit(XtrainR,ytrain)
reduced_dt

DecisionTreeClassifier()

DecisionTreeClassifier()


yTrainPredicted_reduced_dt =  reduced_dt.predict(XtrainR)
yTestPredicted_reduced_dt =  reduced_dt.predict(XtestR)

yTrainPredicted_reduced_dt.size,yTestPredicted_reduced_dt.size

(9864, 2466)


print("Accuracy Score (train):", accuracy_score(y_pred=yTrainPredicted_reduced_dt,y_true= ytrain))
print("Accuracy Score (test):",accuracy_score(y_pred=yTestPredicted_reduced_dt,y_true= ytest))

Accuracy Score (train): 0.9991889699918897
Accuracy Score (test): 0.8491484184914841


plt.figure(figsize=(20,15))
plot_tree(reduced_dt)
plt.show()


Accuracy_dict_reduced_dt = {
    "N":[],
    "train_acc" : [],
    "test_acc" :[]
}
accuracy_df_reduced_dt=pd.DataFrame(Accuracy_dict_reduced_dt)
accuracy_df_reduced_dt


for i in range(1,20):
    new_row=[]
    dt_reduced_dt = DecisionTreeClassifier(random_state=1,max_depth=i)
    dt_reduced_dt.fit(Xtrain,ytrain)
    yTrainPredicted_reduced_dt =  dt_reduced_dt.predict(Xtrain)
    yTestPredicted_reduced_dt =  dt_reduced_dt.predict(Xtest)
    new_row.append(i)
    new_row.append(accuracy_score(y_true=ytrain,y_pred=yTrainPredicted_reduced_dt))
    new_row.append(accuracy_score(y_true=ytest,y_pred=yTestPredicted_reduced_dt))
    accuracy_df_reduced_dt.loc[len(accuracy_df_reduced_dt)] = new_row
accuracy_df_reduced_dt.head()


import plotly.express as px
fig = px.line(x = accuracy_df_reduced_dt["N"],y=[accuracy_df_reduced_dt["train_acc"],accuracy_df_reduced_dt['test_acc']])
fig["data"][0]["name"] ="Train Accuracy"
fig["data"][1]["name"] ="Test Accuracy"
fig.show()


dt_reduced_dt = DecisionTreeClassifier(random_state=1,max_depth=7)
dt_reduced_dt.fit(XtrainR,ytrain)
yTrainPredicted_dt_reduced_dt =  dt_reduced_dt.predict(XtrainR)
yTestPredicted_dt_reduced_dt =  dt_reduced_dt.predict(XtestR)


plt.figure(figsize=(50,25))
plot_tree(dt_reduced_dt,feature_names=list(XtrainR.columns),filled=True,class_names=["NO Transaction","YES Transaction"],fontsize=18)
plt.show()


confusion_matrix(y_true=ytest,y_pred=yTestPredicted_dt_reduced_dt)

array([[1977,   78],
       [ 197,  214]], dtype=int64)


sns.heatmap(confusion_matrix(y_true=ytest,y_pred=yTestPredicted_dt_reduced_dt),annot=True,fmt="g")
plt.xlabel("Prediction Values")
plt.ylabel("Actual Values")
plt.title("Confusion Matrix for Full Decision Tree")
plt.show()


TP_dt_reduced_dt = confusion_matrix(y_true=ytest,y_pred=yTestPredicted_dt_reduced_dt)[1,1]
TN_dt_reduced_dt =confusion_matrix(y_true=ytest,y_pred=yTestPredicted_dt_reduced_dt)[0,0]
FP_dt_reduced_dt = confusion_matrix(y_true=ytest,y_pred=yTestPredicted_dt_reduced_dt)[0,1]
FN_dt_reduced_dt = confusion_matrix(y_true=ytest,y_pred=yTestPredicted_dt_reduced_dt)[1,0]


(TP_dt_reduced_dt + TN_dt_reduced_dt )/ (TP_dt_reduced_dt + TN_dt_reduced_dt +FP_dt_reduced_dt +FN_dt_reduced_dt)

0.8884833738848338


print(classification_report(y_true=ytest,y_pred=yTestPredicted_dt_reduced_dt))

              precision    recall  f1-score   support

           0       0.91      0.96      0.93      2055
           1       0.73      0.52      0.61       411

    accuracy                           0.89      2466
   macro avg       0.82      0.74      0.77      2466
weighted avg       0.88      0.89      0.88      2466


dt_reduced_dt.feature_importances_

array([0.00611547, 0.02887759, 0.05061364, 0.0604334 , 0.8222181 ,
       0.00207366, 0.02966814])


pd.DataFrame({
    "Feature":XtrainR.columns,
    "Importance":dt_reduced_dt.feature_importances_
})


fpr_dt_reduced_dt,tpr_dt_reduced_dt, threshold_dt_reduced_dt = roc_curve(ytest,dt_reduced_dt.predict_proba(XtestR)[:,1])
plt.plot(fpr_dt_reduced_dt,tpr_dt_reduced_dt,label="FPR vs TPR")
plt.plot([0,1], [0,1], linestyle='--', label='No Skill')
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve for Reduced Best Depth Decision Tree")
plt.legend()
plt.show()


roc_auc_score(ytest,yTestPredicted_dt_reduced_dt)

0.7413625304136253


print(classification_report(ytest, ytest_predicted_reduced_logR))

              precision    recall  f1-score   support

           0       0.88      0.97      0.93      2055
           1       0.72      0.35      0.47       411

    accuracy                           0.87      2466
   macro avg       0.80      0.66      0.70      2466
weighted avg       0.86      0.87      0.85      2466


fpr_reduced_logR,tpr_reduced_logR, threshold_reduced_logR = roc_curve(ytest,reduced_logR.predict_proba(XtestR)[:,1])
import matplotlib.pyplot as plt
plt.plot(fpr_reduced_logR,tpr_reduced_logR,label="FPR vs TPR")
plt.plot([0,1], [0,1], linestyle='--', label='No Skill')
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve for Reduced Log Model")
plt.legend()
plt.show()


roc_auc_score(ytest,ytest_predicted_reduced_logR)

0.6605839416058393


gmeans_log = np.sqrt(tpr_reduced_logR * (1-fpr_reduced_logR))


ix_log = np.argmax(gmeans_log)
ix_log

284


print('Best Threshold=%f, G-Mean=%.3f' % (threshold_reduced_logR[ix_log], gmeans_log[ix_log]))

Best Threshold=0.122371, G-Mean=0.826


ytrainPredicted_threshold_reduced_logR = (reduced_logR.predict_proba(XtrainR)[:, 1] > threshold_reduced_logR[ix_log]).astype('float')


ytestPredicted_threshold_reduced_logR = (reduced_logR.predict_proba(XtestR)[:, 1] > threshold_reduced_logR[ix_log]).astype('float')


accuracy_score(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_logR)*100

83.29278183292782


confusion_matrix(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_logR)

array([[1720,  335],
       [  77,  334]], dtype=int64)


sns.heatmap(confusion_matrix(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_logR),annot=True,fmt='g')
plt.xlabel("Predictions")
plt.ylabel("Actual Values")
plt.title("Confusion Matrix for Reduced LogR Model On Best Threshold")
plt.show()


TP_threshold_reduced_logR = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_logR)[1,1]
TN_threshold_reduced_logR = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_logR)[0,0]
FP_threshold_reduced_logR = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_logR)[1,0]
FN_threshold_reduced_logR = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_logR)[0,1]


(TP_threshold_reduced_logR + TN_threshold_reduced_logR )/ (TP_threshold_reduced_logR + TN_threshold_reduced_logR +FP_threshold_reduced_logR +FN_threshold_reduced_logR)

0.8329278183292782


print(classification_report(ytest,ytestPredicted_threshold_reduced_logR))

              precision    recall  f1-score   support

           0       0.96      0.84      0.89      2055
           1       0.50      0.81      0.62       411

    accuracy                           0.83      2466
   macro avg       0.73      0.82      0.76      2466
weighted avg       0.88      0.83      0.85      2466


fpr_threshold_reduced_logR,tpr_threshold_reduced_logR, threshold_threshold_reduced_logR= roc_curve(ytest,reduced_logR.predict_proba(XtestR)[:,1])
import matplotlib.pyplot as plt
plt.plot(fpr_threshold_reduced_logR,tpr_threshold_reduced_logR,label="Best FPR vs TPR")
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve for Reduced Best Threshold LogR Model")
plt.scatter(fpr_threshold_reduced_logR[ix_log], tpr_threshold_reduced_logR[ix_log], marker='o', color='black', label='Best')
plt.plot([0,1], [0,1], linestyle='--', label='No Skill')
plt.legend()
plt.show()


roc_auc_score(ytest,ytestPredicted_threshold_reduced_logR)

0.8248175182481752


print(classification_report(ytest,ytestPredicted_reduced_knn_final))

              precision    recall  f1-score   support

           0       0.90      0.96      0.93      2055
           1       0.70      0.47      0.56       411

    accuracy                           0.88      2466
   macro avg       0.80      0.72      0.75      2466
weighted avg       0.87      0.88      0.87      2466


fpr_reduced_knn_final,tpr_reduced_knn_final, threshold_reduced_knn_final = roc_curve(ytest,reduced_knn_final.predict_proba(XtestScaledR)[:,1])
import matplotlib.pyplot as plt
plt.plot(fpr_reduced_knn_final,tpr_reduced_knn_final,label="FPR vs TPR")
plt.plot([0,1], [0,1], linestyle='--', label='No Skill')
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve for Reduced BEST-K KNN Log Model")
plt.legend()
plt.show()


roc_auc_score(ytest,ytestPredicted_reduced_knn_final)

0.7160583941605839


gmeans_knn = np.sqrt(tpr_reduced_knn_final * (1-fpr_reduced_knn_final))


ix_knn = np.argmax(gmeans_knn)
ix_knn

10


print('Best Threshold=%f, G-Mean=%.3f' % (threshold_reduced_knn_final[ix_knn], gmeans_knn[ix_knn]))

Best Threshold=0.181818, G-Mean=0.811


ytrainPredicted_threshold_reduced_knn = (reduced_knn_final.predict_proba(XtrainScaledR)[:, 1] > threshold_reduced_knn_final[ix_knn]).astype('float')


ytestPredicted_threshold_reduced_knn = (reduced_knn_final.predict_proba(XtestScaledR)[:, 1] >threshold_reduced_knn_final[ix_knn]).astype('float')


accuracy_score(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_knn)*100

85.56366585563666


confusion_matrix(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_knn)

array([[1817,  238],
       [ 118,  293]], dtype=int64)


sns.heatmap(confusion_matrix(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_knn),annot=True,fmt='g')
plt.xlabel("Predictions")
plt.ylabel("Actual Values")
plt.title("Confusion Matrix for Reduced KNN Model On Best Threshold")
plt.show()


TP_threshold_reduced_knn = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_knn)[1,1]
TN_threshold_reduced_knn = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_knn)[0,0]
FP_threshold_reduced_knn = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_knn)[1,0]
FN_threshold_reduced_knn = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_knn)[0,1]


(TP_threshold_reduced_knn + TN_threshold_reduced_knn )/ (TP_threshold_reduced_knn + TN_threshold_reduced_knn +FP_threshold_reduced_knn +FN_threshold_reduced_knn)

0.8556366585563666


print(classification_report(ytest,ytestPredicted_threshold_reduced_knn))

              precision    recall  f1-score   support

           0       0.94      0.88      0.91      2055
           1       0.55      0.71      0.62       411

    accuracy                           0.86      2466
   macro avg       0.75      0.80      0.77      2466
weighted avg       0.87      0.86      0.86      2466


fpr_threshold_reduced_knn,tpr_threshold_reduced_knn, threshold_threshold_reduced_knn= roc_curve(ytest,reduced_knn_final.predict_proba(XtestScaledR)[:,1])
import matplotlib.pyplot as plt
plt.plot(fpr_threshold_reduced_knn,tpr_threshold_reduced_knn,label="Best FPR vs TPR")
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve for Reduced Best Threshold KNN Model")
plt.scatter(fpr_threshold_reduced_knn[ix_knn], tpr_threshold_reduced_knn[ix_knn], marker='o', color='black', label='Best')
plt.plot([0,1], [0,1], linestyle='--', label='No Skill')
plt.legend()
plt.show()


roc_auc_score(ytest,ytestPredicted_threshold_reduced_knn)

0.7985401459854015


print(classification_report(y_true=ytest,y_pred=yTestPredicted_dt_reduced_dt))

              precision    recall  f1-score   support

           0       0.91      0.96      0.93      2055
           1       0.73      0.52      0.61       411

    accuracy                           0.89      2466
   macro avg       0.82      0.74      0.77      2466
weighted avg       0.88      0.89      0.88      2466


fpr_dt_reduced_dt,tpr_dt_reduced_dt, threshold_dt_reduced_dt = roc_curve(ytest,dt_reduced_dt.predict_proba(XtestR)[:,1])
plt.plot(fpr_dt_reduced_dt,tpr_dt_reduced_dt,label="FPR vs TPR")
plt.plot([0,1], [0,1], linestyle='--', label='No Skill')
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve for Reduced Best Depth Decision Tree")
plt.legend()
plt.show()


roc_auc_score(ytest,yTestPredicted_dt_reduced_dt)

0.7413625304136253


gmeans_dt = np.sqrt(tpr_dt_reduced_dt * (1-fpr_dt_reduced_dt))


ix_dt = np.argmax(gmeans_dt)
ix_dt

32


print('Best Threshold=%f, G-Mean=%.3f' % (threshold_dt_reduced_dt[ix_dt], gmeans_dt[ix_dt]))

Best Threshold=0.111111, G-Mean=0.843


ytrainPredicted_threshold_reduced_dt = (dt_reduced_dt.predict_proba(XtrainR)[:, 1] > threshold_dt_reduced_dt[ix_dt]).astype('float')


ytestPredicted_threshold_reduced_dt = (dt_reduced_dt.predict_proba(XtestR)[:, 1] >threshold_dt_reduced_dt[ix_dt]).astype('float')


accuracy_score(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_dt)*100

83.4955393349554


confusion_matrix(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_dt)

array([[1713,  342],
       [  65,  346]], dtype=int64)


sns.heatmap(confusion_matrix(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_dt),annot=True,fmt='g')
plt.xlabel("Predictions")
plt.ylabel("Actual Values")
plt.title("Confusion Matrix for Reduced DT Model On Best Threshold")
plt.show()


TP_threshold_reduced_dt = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_dt)[1,1]
TN_threshold_reduced_dt = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_dt)[0,0]
FP_threshold_reduced_dt = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_dt)[1,0]
FN_threshold_reduced_dt = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_threshold_reduced_dt)[0,1]


(TP_threshold_reduced_dt + TN_threshold_reduced_dt )/ (TP_threshold_reduced_dt + TN_threshold_reduced_dt +FP_threshold_reduced_dt +FN_threshold_reduced_dt)

0.8349553933495539


print(classification_report(ytest,ytestPredicted_threshold_reduced_dt))

              precision    recall  f1-score   support

           0       0.96      0.83      0.89      2055
           1       0.50      0.84      0.63       411

    accuracy                           0.83      2466
   macro avg       0.73      0.84      0.76      2466
weighted avg       0.89      0.83      0.85      2466


fpr_threshold_reduced_dt,tpr_threshold_reduced_dt, threshold_threshold_reduced_dt= roc_curve(ytest,dt_reduced_dt.predict_proba(XtestR)[:,1])
import matplotlib.pyplot as plt
plt.plot(fpr_threshold_reduced_dt,tpr_threshold_reduced_dt,label="Best FPR vs TPR")
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve for Reduced Best Threshold KNN Model")
plt.scatter(fpr_threshold_reduced_dt[ix_dt], tpr_threshold_reduced_dt[ix_dt], marker='o', color='black', label='Best')
plt.plot([0,1], [0,1], linestyle='--', label='No Skill')
plt.legend()
plt.show()


roc_auc_score(ytest,ytestPredicted_threshold_reduced_dt)

0.837712895377129


print('Best Threshold for LogR=%f, G-Mean=%.3f' % (threshold_reduced_logR[ix_log], gmeans_log[ix_log]))

Best Threshold for LogR=0.122371, G-Mean=0.826


acc_test = []
thre = []
acc_train = []
best_log_threshold = threshold_reduced_logR[ix_log]
start_index = np.where(threshold_reduced_logR <= 0.5)[0][0]
end_index = np.where(threshold_reduced_logR == best_log_threshold)[0][0]
for i in range(start_index,end_index):
    ytestPredicted_finalR_ThresholdH = (reduced_logR.predict_proba(XtestR)[:, 1] > threshold_reduced_logR[i]).astype('float')
    ytrainPredicted_finalR_ThresholdH = (reduced_logR.predict_proba(XtrainR)[:, 1] > threshold_reduced_logR[i]).astype('float')    
    acc_test.append(accuracy_score(ytest,ytestPredicted_finalR_ThresholdH))
    thre.append(threshold_reduced_logR[i])    
    acc_train.append(accuracy_score(ytrain,ytrainPredicted_finalR_ThresholdH))


fig = px.line(x = thre,y=[acc_train,acc_test])
fig["data"][0]["name"] = "Accuracy Train"
fig["data"][1]["name"] = "Accuracy Test"
fig.show()


ytestPredicted_logR_BT = (reduced_logR.predict_proba(XtestR)[:, 1] > threshold_reduced_logR[np.where(threshold_reduced_logR>=0.22084)[0][-1]]).astype('float')
ytrainPredicted__logR_BT = (reduced_logR.predict_proba(XtrainR)[:, 1] > threshold_reduced_logR[np.where(threshold_reduced_logR>=0.22084)[0][-1]]).astype('float')


threshold_reduced_logR[np.where(threshold_reduced_logR>=0.22084)[0][-1]]

0.22168234482445176


accuracy_score(y_true=ytest,y_pred=ytestPredicted_logR_BT)*100

88.32116788321169


confusion_matrix(y_true=ytest,y_pred=ytestPredicted_logR_BT)

array([[1933,  122],
       [ 166,  245]], dtype=int64)


sns.heatmap(confusion_matrix(y_true=ytest,y_pred=ytestPredicted_logR_BT),annot=True,fmt='g')
plt.xlabel("Predictions")
plt.ylabel("Actual Values")
plt.title("Confusion Matrix for Reduced LogR Model On Business Threshold")
plt.show()


TP_logR_BT = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_logR_BT)[1,1]
TN_logR_BT = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_logR_BT)[0,0]
FP_logR_BT = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_logR_BT)[1,0]
FN_logR_BT = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_logR_BT)[0,1]


(TP_logR_BT + TN_logR_BT )/ (TP_logR_BT + TN_logR_BT +FP_logR_BT +FN_logR_BT)

0.8832116788321168


print(classification_report(ytest,ytestPredicted_logR_BT))

              precision    recall  f1-score   support

           0       0.92      0.94      0.93      2055
           1       0.67      0.60      0.63       411

    accuracy                           0.88      2466
   macro avg       0.79      0.77      0.78      2466
weighted avg       0.88      0.88      0.88      2466


fpr_threshold_reduced_logR,tpr_threshold_reduced_logR, threshold_threshold_reduced_logR= roc_curve(ytest,reduced_logR.predict_proba(XtestR)[:,1])
import matplotlib.pyplot as plt
plt.plot(fpr_threshold_reduced_logR,tpr_threshold_reduced_logR,label="Best FPR vs TPR")
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve for Reduced Best Threshold LogR Model")
plt.scatter(fpr_threshold_reduced_logR[ix_log], tpr_threshold_reduced_logR[ix_log], marker='o', color='black', label='Best Threshold')
plt.scatter(fpr_threshold_reduced_logR[np.where(threshold_reduced_logR>=0.22084)[0][-1]], tpr_threshold_reduced_logR[np.where(threshold_reduced_logR>=0.22084)[0][-1]], marker='o', color='red', label='Business Threshold')
plt.plot([0,1], [0,1], linestyle='--', label='No Skill')
plt.legend()
plt.show()


roc_auc_score(ytest,ytestPredicted_logR_BT)

0.7683698296836984


print('Best Threshold for KNN=%f, G-Mean=%.3f' % (threshold_threshold_reduced_knn[ix_knn], gmeans_knn[ix_knn]))

Best Threshold for KNN=0.181818, G-Mean=0.811


acc_test = []
thre = []
acc_train = []
best_knn_threshold = threshold_threshold_reduced_knn[ix_knn]
start_index = np.where(threshold_threshold_reduced_knn <= 0.5)[0][0]
end_index = np.where(threshold_threshold_reduced_knn == best_knn_threshold)[0][0]+1
for i in range(start_index,end_index):
    ytestPredicted_finalR_ThresholdH = (reduced_knn_final.predict_proba(XtestScaledR)[:, 1] > threshold_threshold_reduced_knn[i]).astype('float')
    ytrainPredicted_finalR_ThresholdH = (reduced_knn_final.predict_proba(XtrainScaledR)[:, 1] > threshold_threshold_reduced_knn[i]).astype('float')    
    acc_test.append(accuracy_score(ytest,ytestPredicted_finalR_ThresholdH))
    thre.append(threshold_threshold_reduced_knn[i])    
    acc_train.append(accuracy_score(ytrain,ytrainPredicted_finalR_ThresholdH))


fig = px.line(x = thre,y=[acc_train,acc_test])
fig["data"][0]["name"] = "Accuracy Train"
fig["data"][1]["name"] = "Accuracy Test"
fig.show()


ytestPredicted_knn_BT = (reduced_knn_final.predict_proba(XtestScaledR)[:, 1] > threshold_threshold_reduced_knn[np.where(threshold_threshold_reduced_knn>=0.3636)[0][-1]]).astype('float')
ytrainPredicted__knn_BT = (reduced_knn_final.predict_proba(XtrainScaledR)[:, 1] > threshold_threshold_reduced_knn[np.where(threshold_threshold_reduced_knn>=0.3636)[0][-1]]).astype('float')


threshold_threshold_reduced_knn[np.where(threshold_threshold_reduced_knn>=0.3636)[0][-1]]

0.36363636363636365


accuracy_score(y_true=ytest,y_pred=ytestPredicted_knn_BT)*100

87.95620437956204


confusion_matrix(y_true=ytest,y_pred=ytestPredicted_knn_BT)

array([[1943,  112],
       [ 185,  226]], dtype=int64)


sns.heatmap(confusion_matrix(y_true=ytest,y_pred=ytestPredicted_knn_BT),annot=True,fmt='g')
plt.xlabel("Predictions")
plt.ylabel("Actual Values")
plt.title("Confusion Matrix for Reduced KNN Model On Business Threshold")
plt.show()


TP_knn_BT = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_knn_BT)[1,1]
TN_knn_BT = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_knn_BT)[0,0]
FP_knn_BT = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_knn_BT)[1,0]
FN_knn_BT = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_knn_BT)[0,1]


(TP_knn_BT + TN_knn_BT )/ (TP_knn_BT + TN_knn_BT +FP_knn_BT +FN_knn_BT)

0.8795620437956204


print(classification_report(ytest,ytestPredicted_knn_BT))

              precision    recall  f1-score   support

           0       0.91      0.95      0.93      2055
           1       0.67      0.55      0.60       411

    accuracy                           0.88      2466
   macro avg       0.79      0.75      0.77      2466
weighted avg       0.87      0.88      0.87      2466


fpr_threshold_reduced_knn[np.where(threshold_threshold_reduced_knn>=0.3636)[0][-1]]

0.08029197080291971


fpr_threshold_reduced_knn,tpr_threshold_reduced_knn, threshold_threshold_reduced_knn= roc_curve(ytest,reduced_knn_final.predict_proba(XtestScaledR)[:,1])
import matplotlib.pyplot as plt
plt.plot(fpr_threshold_reduced_knn,tpr_threshold_reduced_knn,label="Best FPR vs TPR")
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve for Reduced Best Threshold KNN Model")
plt.scatter(fpr_threshold_reduced_knn[ix_knn], tpr_threshold_reduced_knn[ix_knn], marker='o', color='black', label='Best')
# plt.scatter(fpr_threshold_reduced_logR[np.where(threshold_threshold_reduced_knn>=0.3636)[0][-1]], tpr_threshold_reduced_logR[np.where(threshold_threshold_reduced_knn>=0.3636)[0][-1]], marker='o', color='red', label='Business Threshold')
plt.scatter(fpr_threshold_reduced_knn[np.where(threshold_threshold_reduced_knn>=0.3636)[0][-1]], tpr_threshold_reduced_knn[np.where(threshold_threshold_reduced_knn>=0.3636)[0][-1]], marker='o', color='red', label='Business Threshold')

plt.plot([0,1], [0,1], linestyle='--', label='No Skill')
plt.legend()
plt.show()


roc_auc_score(ytest,ytestPredicted_knn_BT)

0.7476885644768856


print('Best Threshold for Decision Trees = %f, G-Mean=%.3f' % (threshold_dt_reduced_dt[ix_dt], gmeans_dt[ix_dt]))

Best Threshold for Decision Trees = 0.111111, G-Mean=0.843


acc_test = []
thre = []
acc_train = []
best_dt_threshold = threshold_dt_reduced_dt[ix_dt]
start_index = np.where(threshold_dt_reduced_dt <= 0.5)[0][0]
end_index = np.where(threshold_dt_reduced_dt == best_dt_threshold)[0][0]+1
for i in range(start_index,end_index):
    ytestPredicted_finalR_ThresholdH = (dt_reduced_dt.predict_proba(XtestR)[:, 1] > threshold_dt_reduced_dt[i]).astype('float')
    ytrainPredicted_finalR_ThresholdH = (dt_reduced_dt.predict_proba(XtrainR)[:, 1] > threshold_dt_reduced_dt[i]).astype('float')    
    acc_test.append(accuracy_score(ytest,ytestPredicted_finalR_ThresholdH))
    thre.append(threshold_dt_reduced_dt[i])    
    acc_train.append(accuracy_score(ytrain,ytrainPredicted_finalR_ThresholdH))


fig = px.line(x = thre,y=[acc_train,acc_test])
fig["data"][0]["name"] = "Accuracy Train"
fig["data"][1]["name"] = "Accuracy Test"
fig.show()


ytestPredicted_dt_BT = (dt_reduced_dt.predict_proba(XtestR)[:, 1] > threshold_dt_reduced_dt[np.where(threshold_dt_reduced_dt>=0.3888)[0][-1]]).astype('float')
ytrainPredicted__dt_BT = (dt_reduced_dt.predict_proba(XtrainR)[:, 1] > threshold_dt_reduced_dt[np.where(threshold_dt_reduced_dt>=0.3888)[0][-1]]).astype('float')


threshold_dt_reduced_dt[np.where(threshold_dt_reduced_dt>=0.3888)[0][-1]]

0.3888888888888889


accuracy_score(y_true=ytest,y_pred=ytestPredicted_dt_BT)*100

88.44282238442823


confusion_matrix(y_true=ytest,y_pred=ytestPredicted_dt_BT)

array([[1938,  117],
       [ 168,  243]], dtype=int64)


sns.heatmap(confusion_matrix(y_true=ytest,y_pred=ytestPredicted_dt_BT),annot=True,fmt='g')
plt.xlabel("Predictions")
plt.ylabel("Actual Values")
plt.title("Confusion Matrix for Reduced Decision Tree Model On Business Threshold")
plt.show()


TP_dt_BT = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_dt_BT)[1,1]
TN_dt_BT = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_dt_BT)[0,0]
FP_dt_BT = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_dt_BT)[1,0]
FN_dt_BT = confusion_matrix(y_true=ytest,y_pred=ytestPredicted_dt_BT)[0,1]


(TP_dt_BT + TN_dt_BT )/ (TP_dt_BT + TN_dt_BT +FP_dt_BT +FN_dt_BT)

0.8844282238442822


print(classification_report(ytest,ytestPredicted_dt_BT))

              precision    recall  f1-score   support

           0       0.92      0.94      0.93      2055
           1       0.68      0.59      0.63       411

    accuracy                           0.88      2466
   macro avg       0.80      0.77      0.78      2466
weighted avg       0.88      0.88      0.88      2466


fpr_threshold_reduced_knn[np.where(threshold_threshold_reduced_knn>=0.3636)[0][-1]]

0.08029197080291971


fpr_dt_reduced_dt,tpr_dt_reduced_dt, threshold_dt_reduced_dt= roc_curve(ytest,dt_reduced_dt.predict_proba(XtestR)[:,1])
import matplotlib.pyplot as plt
plt.plot(fpr_dt_reduced_dt,tpr_dt_reduced_dt,label="Best FPR vs TPR")
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve for Reduced Best Threshold Decision Tree Model")
plt.scatter(fpr_dt_reduced_dt[ix_dt], tpr_dt_reduced_dt[ix_dt], marker='o', color='black', label='Best Threshold')
# plt.scatter(fpr_threshold_reduced_logR[np.where(threshold_threshold_reduced_knn>=0.3636)[0][-1]], tpr_threshold_reduced_logR[np.where(threshold_threshold_reduced_knn>=0.3636)[0][-1]], marker='o', color='red', label='Business Threshold')
plt.scatter(fpr_dt_reduced_dt[np.where(threshold_dt_reduced_dt>=0.3888)[0][-1]], tpr_dt_reduced_dt[np.where(threshold_dt_reduced_dt>=0.3888)[0][-1]], marker='o', color='red', label='Business Threshold')
plt.plot([0,1], [0,1], linestyle='--', label='No Skill')
plt.legend()
plt.show()


roc_auc_score(ytest,ytestPredicted_dt_BT)

0.7671532846715329


df_kmeans = df.iloc[:,:13]      # creating a seperate dataframe for kmeans clustering
df_kmeans


scaler = StandardScaler()
scaler.fit(df_kmeans)
df_kmeans_Scaled = scaler.transform(df_kmeans)

df_kmeans_Scaled2 = normalize(df_kmeans)


# Data scaled using Standard Scaler

inertia=[]
number_of_clusters = range(2,50)

for i in number_of_clusters:
    km = KMeans(n_clusters = i, random_state = 0)
    km.fit(df_kmeans_Scaled)
    inertia.append(km.inertia_)
    print("Cluster for i = ",i," Completed")

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\cluster\_kmeans.py:1412: FutureWarning:

The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning

Cluster for i =  2  Completed

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\cluster\_kmeans.py:1412: FutureWarning:

The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning

Cluster for i =  3  Completed

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\cluster\_kmeans.py:1412: FutureWarning:

The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning

Cluster for i =  4  Completed

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\cluster\_kmeans.py:1412: FutureWarning:

The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning

Cluster for i =  5  Completed

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\cluster\_kmeans.py:1412: FutureWarning:

The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning

Cluster for i =  6  Completed


plt.plot(number_of_clusters, inertia)
plt.show()


# data scaled using Normalize

inertia2=[]
number_of_clusters2 = range(2,50)

for i in number_of_clusters2:
    km2 = KMeans(n_clusters = i, random_state = 0)
    km2.fit(df_kmeans_Scaled2)
    inertia2.append(km2.inertia_)
    print("Cluster for i = ",i," Completed")

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\cluster\_kmeans.py:1412: FutureWarning:

The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning

Cluster for i =  2  Completed

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\cluster\_kmeans.py:1412: FutureWarning:

The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning

Cluster for i =  3  Completed

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\cluster\_kmeans.py:1412: FutureWarning:

The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning

Cluster for i =  4  Completed

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\cluster\_kmeans.py:1412: FutureWarning:

The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning

Cluster for i =  5  Completed

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\cluster\_kmeans.py:1412: FutureWarning:

The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning

Cluster for i =  6  Completed


plt.plot(number_of_clusters2, inertia2)
plt.show()


# Clustering for n=3
km = KMeans(n_clusters = 3, random_state = 1)
km.fit(df_kmeans_Scaled)
y3=km.predict(df_kmeans_Scaled)
df['3CC']= y3

km2 = KMeans(n_clusters = 3, random_state = 1)
km2.fit(df_kmeans_Scaled2)
y3_2=km2.predict(df_kmeans_Scaled2)
df['3CC_2']= y3_2

# Clustering for n=4
km = KMeans(n_clusters = 4, random_state = 1)
km.fit(df_kmeans_Scaled)
y4=km.predict(df_kmeans_Scaled)
df['4CC']= y4

km2 = KMeans(n_clusters = 4, random_state = 1)
km2.fit(df_kmeans_Scaled2)
y4_2=km2.predict(df_kmeans_Scaled2)
df['4CC_2']= y4_2

## Clustering for n=5
km = KMeans(n_clusters = 5, random_state = 1)
km.fit(df_kmeans_Scaled)
y5=km.predict(df_kmeans_Scaled)
df['5CC']= y5

km2 = KMeans(n_clusters = 5, random_state = 1)
km2.fit(df_kmeans_Scaled2)
y5_2=km2.predict(df_kmeans_Scaled2)
df['5CC_2']= y5_2

# Clustering for n=6
km = KMeans(n_clusters = 6, random_state = 1)
km.fit(df_kmeans_Scaled)
y6=km.predict(df_kmeans_Scaled)
df['6CC']= y6

km2 = KMeans(n_clusters = 6, random_state = 1)
km2.fit(df_kmeans_Scaled2)
y6_2=km2.predict(df_kmeans_Scaled2)
df['6CC_2']= y6_2

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\cluster\_kmeans.py:1412: FutureWarning:

The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\cluster\_kmeans.py:1412: FutureWarning:

The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\cluster\_kmeans.py:1412: FutureWarning:

The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\cluster\_kmeans.py:1412: FutureWarning:

The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\cluster\_kmeans.py:1412: FutureWarning:

The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\cluster\_kmeans.py:1412: FutureWarning:

The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\cluster\_kmeans.py:1412: FutureWarning:

The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning

C:\ProgramData\anaconda3\Lib\site-packages\sklearn\cluster\_kmeans.py:1412: FutureWarning:

The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning


table = pd.pivot_table(df, index='3CC',values=['Transaction',"Transaction Status", "VisitorType Status","PageValues","ExitRates","Administrative_Duration","Informational_Duration","ProductRelated_Duration"],
                       aggfunc={"Transaction":"count","Transaction Status":"sum","VisitorType Status":"sum","ExitRates":"mean"
                               ,"PageValues":"mean","Administrative_Duration":"mean","Informational_Duration":"mean","ProductRelated_Duration":"mean"})
table.columns
cols = [ 'Transaction', 'Transaction Status', 'VisitorType Status','PageValues', "ExitRates", 'Administrative_Duration', 'Informational_Duration','ProductRelated_Duration',]
table = table[cols]
table.rename(columns={'Transaction':'Count of Visitors',
                      'Transaction Status':'Sum of Transactions Made',
                      'VisitorType Status': 'Count of Returning Visitors',
                      'PageValues':'Average Page Values',
                      'ExitRates':'Average Exit Rates',
                      'Administrative_Duration':'Average Administrative_Duration',
                      'Informational_Duration':'Average Informational_Duration',
                      'ProductRelated_Duration':'Average ProductRelated_Duration',
                     },inplace=True)
table


table2 = pd.pivot_table(df, index='3CC_2',values=['Transaction',"Transaction Status", "VisitorType Status","PageValues","ExitRates","Administrative_Duration","Informational_Duration","ProductRelated_Duration"],
                       aggfunc={"Transaction":"count","Transaction Status":"sum","VisitorType Status":"sum","ExitRates":"mean"
                               ,"PageValues":"mean","Administrative_Duration":"mean","Informational_Duration":"mean","ProductRelated_Duration":"mean"})
table2.columns
cols = [ 'Transaction', 'Transaction Status', 'VisitorType Status','PageValues', "ExitRates", 'Administrative_Duration', 'Informational_Duration','ProductRelated_Duration',]
table2 = table2[cols]
table2.rename(columns={'Transaction':'Count of Visitors',
                      'Transaction Status':'Sum of Transactions Made',
                      'VisitorType Status': 'Count of Returning Visitors',
                      'PageValues':'Average Page Values',
                      'ExitRates':'Average Exit Rates',
                      'Administrative_Duration':'Average Administrative_Duration',
                      'Informational_Duration':'Average Informational_Duration',
                      'ProductRelated_Duration':'Average ProductRelated_Duration',
                     },inplace=True)
table2


table = pd.pivot_table(df, index='4CC',values=['Transaction',"Transaction Status", "VisitorType Status","PageValues","ExitRates","Administrative_Duration","Informational_Duration","ProductRelated_Duration"],
                       aggfunc={"Transaction":"count","Transaction Status":"sum","VisitorType Status":"sum","ExitRates":"mean"
                               ,"PageValues":"mean","Administrative_Duration":"mean","Informational_Duration":"mean","ProductRelated_Duration":"mean"})
table.columns
cols = [ 'Transaction', 'Transaction Status', 'VisitorType Status','PageValues', "ExitRates", 'Administrative_Duration', 'Informational_Duration','ProductRelated_Duration',]
table = table[cols]
table.rename(columns={'Transaction':'Count of Visitors',
                      'Transaction Status':'Sum of Transactions Made',
                      'VisitorType Status': 'Count of Returning Visitors',
                      'PageValues':'Average Page Values',
                      'ExitRates':'Average Exit Rates',
                      'Administrative_Duration':'Average Administrative_Duration',
                      'Informational_Duration':'Average Informational_Duration',
                      'ProductRelated_Duration':'Average ProductRelated_Duration',
                     },inplace=True)
table


table2 = pd.pivot_table(df, index='4CC_2',values=['Transaction',"Transaction Status", "VisitorType Status","PageValues","ExitRates","Administrative_Duration","Informational_Duration","ProductRelated_Duration"],
                       aggfunc={"Transaction":"count","Transaction Status":"sum","VisitorType Status":"sum","ExitRates":"mean"
                               ,"PageValues":"mean","Administrative_Duration":"mean","Informational_Duration":"mean","ProductRelated_Duration":"mean"})
table2.columns
cols = [ 'Transaction', 'Transaction Status', 'VisitorType Status','PageValues', "ExitRates", 'Administrative_Duration', 'Informational_Duration','ProductRelated_Duration',]
table2 = table2[cols]
table2.rename(columns={'Transaction':'Count of Visitors',
                      'Transaction Status':'Sum of Transactions Made',
                      'VisitorType Status': 'Count of Returning Visitors',
                      'PageValues':'Average Page Values',
                      'ExitRates':'Average Exit Rates',
                      'Administrative_Duration':'Average Administrative_Duration',
                      'Informational_Duration':'Average Informational_Duration',
                      'ProductRelated_Duration':'Average ProductRelated_Duration',
                     },inplace=True)
table2


table = pd.pivot_table(df, index='5CC',values=['Transaction',"Transaction Status", "VisitorType Status","PageValues","ExitRates","Administrative_Duration","Informational_Duration","ProductRelated_Duration"],
                       aggfunc={"Transaction":"count","Transaction Status":"sum","VisitorType Status":"sum","ExitRates":"mean"
                               ,"PageValues":"mean","Administrative_Duration":"mean","Informational_Duration":"mean","ProductRelated_Duration":"mean"})
table.columns
cols = [ 'Transaction', 'Transaction Status', 'VisitorType Status','PageValues', "ExitRates", 'Administrative_Duration', 'Informational_Duration','ProductRelated_Duration',]
table = table[cols]
table.rename(columns={'Transaction':'Count of Visitors',
                      'Transaction Status':'Sum of Transactions Made',
                      'VisitorType Status': 'Count of Returning Visitors',
                      'PageValues':'Average Page Values',
                      'ExitRates':'Average Exit Rates',
                      'Administrative_Duration':'Average Administrative_Duration',
                      'Informational_Duration':'Average Informational_Duration',
                      'ProductRelated_Duration':'Average ProductRelated_Duration',
                     },inplace=True)
table


table2 = pd.pivot_table(df, index='5CC_2',values=['Transaction',"Transaction Status", "VisitorType Status","PageValues","ExitRates","Administrative_Duration","Informational_Duration","ProductRelated_Duration"],
                       aggfunc={"Transaction":"count","Transaction Status":"sum","VisitorType Status":"sum","ExitRates":"mean"
                               ,"PageValues":"mean","Administrative_Duration":"mean","Informational_Duration":"mean","ProductRelated_Duration":"mean"})
table2.columns
cols = [ 'Transaction', 'Transaction Status', 'VisitorType Status','PageValues', "ExitRates", 'Administrative_Duration', 'Informational_Duration','ProductRelated_Duration',]
table2 = table2[cols]
table2.rename(columns={'Transaction':'Count of Visitors',
                      'Transaction Status':'Sum of Transactions Made',
                      'VisitorType Status': 'Count of Returning Visitors',
                      'PageValues':'Average Page Values',
                      'ExitRates':'Average Exit Rates',
                      'Administrative_Duration':'Average Administrative_Duration',
                      'Informational_Duration':'Average Informational_Duration',
                      'ProductRelated_Duration':'Average ProductRelated_Duration',
                     },inplace=True)
table2


table = pd.pivot_table(df, index='6CC',values=['Transaction',"Transaction Status", "VisitorType Status","PageValues","ExitRates","Administrative_Duration","Informational_Duration","ProductRelated_Duration"],
                       aggfunc={"Transaction":"count","Transaction Status":"sum","VisitorType Status":"sum","ExitRates":"mean"
                               ,"PageValues":"mean","Administrative_Duration":"mean","Informational_Duration":"mean","ProductRelated_Duration":"mean"})
table.columns
cols = [ 'Transaction', 'Transaction Status', 'VisitorType Status','PageValues', "ExitRates", 'Administrative_Duration', 'Informational_Duration','ProductRelated_Duration',]
table = table[cols]
table.rename(columns={'Transaction':'Count of Visitors',
                      'Transaction Status':'Sum of Transactions Made',
                      'VisitorType Status': 'Count of Returning Visitors',
                      'PageValues':'Average Page Values',
                      'ExitRates':'Average Exit Rates',
                      'Administrative_Duration':'Average Administrative_Duration',
                      'Informational_Duration':'Average Informational_Duration',
                      'ProductRelated_Duration':'Average ProductRelated_Duration',
                     },inplace=True)
table


table2 = pd.pivot_table(df, index='6CC_2',values=['Transaction',"Transaction Status", "VisitorType Status","PageValues","ExitRates","Administrative_Duration","Informational_Duration","ProductRelated_Duration"],
                       aggfunc={"Transaction":"count","Transaction Status":"sum","VisitorType Status":"sum","ExitRates":"mean"
                               ,"PageValues":"mean","Administrative_Duration":"mean","Informational_Duration":"mean","ProductRelated_Duration":"mean"})
table2.columns
cols = [ 'Transaction', 'Transaction Status', 'VisitorType Status','PageValues', "ExitRates", 'Administrative_Duration', 'Informational_Duration','ProductRelated_Duration',]
table2 = table2[cols]
table2.rename(columns={'Transaction':'Count of Visitors',
                      'Transaction Status':'Sum of Transactions Made',
                      'VisitorType Status': 'Count of Returning Visitors',
                      'PageValues':'Average Page Values',
                      'ExitRates':'Average Exit Rates',
                      'Administrative_Duration':'Average Administrative_Duration',
                      'Informational_Duration':'Average Informational_Duration',
                      'ProductRelated_Duration':'Average ProductRelated_Duration',
                     },inplace=True)
table2


table = pd.pivot_table(df, index='4CC',values=['Transaction',"Transaction Status", "VisitorType Status","PageValues","ExitRates","Administrative_Duration","Informational_Duration","ProductRelated_Duration"],
                       aggfunc={"Transaction":"count","Transaction Status":"sum","VisitorType Status":"sum","ExitRates":"mean"
                               ,"PageValues":"mean","Administrative_Duration":"mean","Informational_Duration":"mean","ProductRelated_Duration":"mean"})
table.columns
cols = [ 'Transaction', 'Transaction Status', 'VisitorType Status','PageValues', "ExitRates", 'Administrative_Duration', 'Informational_Duration','ProductRelated_Duration',]
table = table[cols]
table.rename(columns={'Transaction':'Count of Visitors',
                      'Transaction Status':'Sum of Transactions Made',
                      'VisitorType Status': 'Count of Returning Visitors',
                      'PageValues':'Average Page Values',
                      'ExitRates':'Average Exit Rates',
                      'Administrative_Duration':'Average Administrative_Duration',
                      'Informational_Duration':'Average Informational_Duration',
                      'ProductRelated_Duration':'Average ProductRelated_Duration',
                     },inplace=True)
table


table.reset_index(inplace=True)


table.iloc[:,[0,1,2,3,4,6,7,8]]

	Administrative	Administrative_Duration	Informational	Informational_Duration	ProductRelated	ProductRelated_Duration	BounceRates	ExitRates	PageValues	SpecialDay
count	12330.000000	12330.000000	12330.000000	12330.000000	12330.000000	12330.000000	12330.000000	12330.000000	12330.000000	12330.000000
mean	2.315166	80.818611	0.503569	34.472398	31.731468	1194.746220	0.022191	0.043073	5.889258	0.061427
std	3.321784	176.779107	1.270156	140.749294	44.475503	1913.669288	0.048488	0.048597	18.568437	0.198917
min	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000
25%	0.000000	0.000000	0.000000	0.000000	7.000000	184.137500	0.000000	0.014286	0.000000	0.000000
50%	1.000000	7.500000	0.000000	0.000000	18.000000	598.936905	0.003112	0.025156	0.000000	0.000000
75%	4.000000	93.256250	0.000000	0.000000	38.000000	1464.157214	0.016813	0.050000	0.000000	0.000000
max	27.000000	3398.750000	24.000000	2549.375000	705.000000	63973.522230	0.200000	0.200000	361.763742	1.000000

	Administrative	Administrative_Duration	Informational	Informational_Duration	ProductRelated	ProductRelated_Duration	BounceRates	ExitRates	PageValues	SpecialDay	Weekend	VisitorType Status	Weekend Status	Transaction Status
Administrative	1.000000	0.601583	0.376850	0.255848	0.431119	0.373939	-0.223563	-0.316483	0.098990	-0.094778	0.026417	-0.022884	0.026417	0.138917
Administrative_Duration	0.601583	1.000000	0.302710	0.238031	0.289087	0.355422	-0.144170	-0.205798	0.067608	-0.073304	0.014990	-0.022525	0.014990	0.093587
Informational	0.376850	0.302710	1.000000	0.618955	0.374164	0.387505	-0.116114	-0.163666	0.048632	-0.048219	0.035785	0.057399	0.035785	0.095200
Informational_Duration	0.255848	0.238031	0.618955	1.000000	0.280046	0.347364	-0.074067	-0.105276	0.030861	-0.030577	0.024078	0.045501	0.024078	0.070345
ProductRelated	0.431119	0.289087	0.374164	0.280046	1.000000	0.860927	-0.204578	-0.292526	0.056282	-0.023958	0.016092	0.128738	0.016092	0.158538
ProductRelated_Duration	0.373939	0.355422	0.387505	0.347364	0.860927	1.000000	-0.184541	-0.251984	0.052823	-0.036380	0.007311	0.120489	0.007311	0.152373
BounceRates	-0.223563	-0.144170	-0.116114	-0.074067	-0.204578	-0.184541	1.000000	0.913004	-0.119386	0.072702	-0.046514	0.129908	-0.046514	-0.150673
ExitRates	-0.316483	-0.205798	-0.163666	-0.105276	-0.292526	-0.251984	0.913004	1.000000	-0.174498	0.102242	-0.062587	0.171987	-0.062587	-0.207071
PageValues	0.098990	0.067608	0.048632	0.030861	0.056282	0.052823	-0.119386	-0.174498	1.000000	-0.063541	0.012002	-0.115825	0.012002	0.492569
SpecialDay	-0.094778	-0.073304	-0.048219	-0.030577	-0.023958	-0.036380	0.072702	0.102242	-0.063541	1.000000	-0.016767	0.087123	-0.016767	-0.082305
Weekend	0.026417	0.014990	0.035785	0.024078	0.016092	0.007311	-0.046514	-0.062587	0.012002	-0.016767	1.000000	-0.039444	1.000000	0.029295
VisitorType Status	-0.022884	-0.022525	0.057399	0.045501	0.128738	0.120489	0.129908	0.171987	-0.115825	0.087123	-0.039444	1.000000	-0.039444	-0.103843
Weekend Status	0.026417	0.014990	0.035785	0.024078	0.016092	0.007311	-0.046514	-0.062587	0.012002	-0.016767	1.000000	-0.039444	1.000000	0.029295
Transaction Status	0.138917	0.093587	0.095200	0.070345	0.158538	0.152373	-0.150673	-0.207071	0.492569	-0.082305	0.029295	-0.103843	0.029295	1.000000

	VisitorType	VisitorType Status
0	New_Visitor	1779
1	Returning_Visitor	10551

	Transaction	VisitorType	Transaction Status
0	No	New_Visitor	1341
1	No	Returning_Visitor	9081
2	Yes	New_Visitor	438
3	Yes	Returning_Visitor	1470

	N	train_acc	test_acc
0	1.0	0.999696	0.844282
1	2.0	0.928325	0.871857
2	3.0	0.926399	0.873479
3	4.0	0.911598	0.877129
4	5.0	0.914538	0.875912

	Administrative	Administrative_Duration	Informational	ProductRelated	ProductRelated_Duration	BounceRates	ExitRates	PageValues	VisitorType	Weekend	Transaction
12324	0	0.0	1	16	503.000000	0.000000	0.037647	0.000000	Returning_Visitor	False	No
12325	3	145.0	0	53	1783.791667	0.007143	0.029031	12.241717	Returning_Visitor	True	No
12326	0	0.0	0	5	465.750000	0.000000	0.021333	0.000000	Returning_Visitor	True	No
12327	0	0.0	0	6	184.250000	0.083333	0.086667	0.000000	Returning_Visitor	True	No
12328	4	75.0	0	15	346.000000	0.000000	0.021053	0.000000	Returning_Visitor	False	No
12329	0	0.0	0	3	21.250000	0.000000	0.066667	0.000000	New_Visitor	True	No

	ProductRelated	ProductRelated_Duration	BounceRates	ExitRates	VisitorType	Weekend	Transaction	VisitorType Status	Weekend Status
0	1	0.000000	0.20	0.20	Returning_Visitor	False	No	1	0
1	2	64.000000	0.00	0.10	Returning_Visitor	False	No	1	0
2	1	0.000000	0.20	0.20	Returning_Visitor	False	No	1	0
3	2	2.666667	0.05	0.14	Returning_Visitor	False	No	1	0
4	10	627.500000	0.02	0.05	Returning_Visitor	True	No	1	1

	Administrative	Administrative_Duration	Informational	Informational_Duration	ProductRelated	ProductRelated_Duration	BounceRates	ExitRates	PageValues	VisitorType Status	Weekend Status
1785	0	0.0	0	0.0	7	95.000000	0.014286	0.061905	0.000000	1	0
10407	2	14.0	0	0.0	81	1441.910588	0.002469	0.013933	2.769599	1	0
286	0	0.0	0	0.0	1	0.000000	0.200000	0.200000	0.000000	1	0
6520	5	49.2	4	379.0	5	74.600000	0.000000	0.018182	8.326728	0	0
12251	0	0.0	1	5.0	9	279.000000	0.040000	0.041667	0.000000	0	1

	N	train_acc	test_acc
0	1.0	0.876723	0.872263
1	2.0	0.893958	0.876318
2	3.0	0.896796	0.879157
3	4.0	0.903893	0.881995
4	5.0	0.906427	0.880373

	Feature	Importance
0	Administrative	0.031706
1	Administrative_Duration	0.005930
2	Informational	0.000000
3	Informational_Duration	0.000977
4	ProductRelated	0.009399
5	ProductRelated_Duration	0.008751
6	BounceRates	0.087197
7	ExitRates	0.007525
8	PageValues	0.848516
9	SpecialDay	0.000000
10	VisitorType Status	0.000000
11	Weekend Status	0.000000

Comparision	Full LogR	Full Scale BEST-K KNN	Full Scale BEST-Depth DT
Model Accuracy	87.18%	87.87%	88.19%
False Negatives	265	253	208
False Positives	51	46	83
Precision (NO)	0.88	0.89	0.90
Recall (NO)	0.98	0.98	0.96
F1-Score (NO)	0.93	0.93	0.93
Precision (YES)	0.74	0.77	0.71
Recall (YES)	0.36	0.38	0.49
F1-Score (YES)	0.48	0.51	0.58
AUC Score	0.665	0.685	0.726

Dep. Variable:	Transaction Status	No. Observations:	9864
Model:	GLM	Df Residuals:	9851
Model Family:	Binomial	Df Model:	12
Link Function:	Logit	Scale:	1.0000
Method:	IRLS	Log-Likelihood:	-2915.8
Date:	Tue, 05 Dec 2023	Deviance:	5831.7
Time:	22:47:23	Pearson chi2:	4.35e+06
No. Iterations:	8	Pseudo R-squ. (CS):	0.2292
Covariance Type:	nonrobust

	coef	std err	z	P>\|z\|	[0.025	0.975]
const	-1.8175	0.102	-17.841	0.000	-2.017	-1.618
Administrative	-0.0015	0.012	-0.121	0.903	-0.026	0.023
Administrative_Duration	-0.0002	0.000	-1.017	0.309	-0.001	0.000
Informational	0.0645	0.029	2.197	0.028	0.007	0.122
Informational_Duration	-0.0002	0.000	-0.723	0.470	-0.001	0.000
ProductRelated	0.0032	0.001	2.533	0.011	0.001	0.006
ProductRelated_Duration	5.873e-05	2.98e-05	1.973	0.048	3.97e-07	0.000
BounceRates	-1.4879	3.542	-0.420	0.674	-8.430	5.454
ExitRates	-16.6350	2.686	-6.193	0.000	-21.899	-11.371
PageValues	0.0802	0.003	30.517	0.000	0.075	0.085
SpecialDay	-1.1722	0.271	-4.328	0.000	-1.703	-0.641
VisitorType Status	-0.3353	0.094	-3.575	0.000	-0.519	-0.151
Weekend Status	0.1361	0.079	1.716	0.086	-0.019	0.292

	Informational	ProductRelated	ProductRelated_Duration	ExitRates	PageValues	VisitorType Status
8916	0	48	1052.255952	0.013043	0.000000	1
772	2	83	2503.881781	0.004916	2.086218	1
12250	0	126	4310.004668	0.012823	3.451072	1
7793	0	10	606.666667	0.026389	36.672294	1
6601	6	168	4948.398759	0.013528	10.150644	1

Comparision	Full LogR	Reduced - LogR
Model Accuracy	87.18%	87.14%
False Negatives	265	262
False Positives	51	55
Precision (NO)	0.88	0.88
Recall (NO)	0.98	0.97
F1-Score (NO)	0.93	0.93
Precision (YES)	0.74	0.73
Recall (YES)	0.36	0.36
F1-Score (YES)	0.48	0.48
AUC Score	0.665	0.667

	Feature	Importance
0	Informational	0.006115
1	ProductRelated	0.028878
2	ProductRelated_Duration	0.050614
3	ExitRates	0.060433
4	PageValues	0.822218
5	SpecialDay	0.002074
6	VisitorType Status	0.029668

Comparision	Full DT	Reduced - DT
Model Accuracy	88.19%	88.88%
False Negatives	208	197
False Positives	83	78
Precision (NO)	0.90	0.91
Recall (NO)	0.96	0.96
F1-Score (NO)	0.93	0.93
Precision (YES)	0.71	0.73
Recall (YES)	0.49	0.52
F1-Score (YES)	0.58	0.61
AUC Score	0.7261	0.7413

Comparision	Best Threshold - Reduced LogR Model	Best Threshold - Reduced KNN	Best Threshold - Reduced DT
Model Accuracy	84.83%	85.56%	83.49%
False Negatives	94	118	65
False Postives	280	238	342
Precision (NO)	0.95	0.94	0.96
Recall (NO)	0.86	0.88	0.83
F1-Score (NO)	0.90	0.91	0.89
Precision (YES)	0.53	0.55	0.50
Recall (YES)	0.77	0.71	0.84
F1-Score (YES)	0.63	0.62	0.63
AUC Score	0.8175	0.7985	0.8377

Comparision	Business Threshold - Reduced LogR Model	Business Threshold - Reduced KNN	Business Threshold - Reduced DT
Practical Threshold	0.2208	0.3636	0.3888
Model Accuracy	88.36%	87.95%	88.44%
False Negatives	164	185	168
False Postives	123	112	117
Precision (NO)	0.92	0.91	0.92
Recall (NO)	0.94	0.95	0.94
F1-Score (NO)	0.93	0.93	0.93
Precision (YES)	0.63	0.67	0.68
Recall (YES)	0.60	0.55	0.59
F1-Score (YES)	0.63	0.60	0.63
AUC Score	0.7705	0.7476	0.7671 - Moderate

	Count of Visitors	Sum of Transactions Made	Count of Returning Visitors	Average Page Values	Average Exit Rates	Average Administrative_Duration	Average Informational_Duration	Average ProductRelated_Duration
3CC
0	1054	5	1009	0.000000	0.180191	1.364769	0.086528	57.929836
1	9618	1387	7971	5.782345	0.032114	50.764207	8.358147	864.859889
2	1658	516	1571	10.253288	0.019477	305.672409	207.819548	3831.085905

	Count of Visitors	Sum of Transactions Made	Count of Returning Visitors	Average Page Values	Average Exit Rates	Average Administrative_Duration	Average Informational_Duration	Average ProductRelated_Duration
3CC_2
0	10564	1754	9229	6.493919	0.033730	66.577330	35.752847	1361.484717
1	728	3	682	0.000000	0.198339	0.000000	0.015110	0.023123
2	1038	151	640	3.865882	0.029265	282.437916	45.607501	335.722073

	Count of Visitors	Sum of Transactions Made	Count of Returning Visitors	Average Page Values	Average Exit Rates	Average Administrative_Duration	Average Informational_Duration	Average ProductRelated_Duration
4CC
0	1674	1616	1229	31.885464	0.019398	85.637681	19.275564	1297.969759
1	8347	0	7104	1.247085	0.034125	51.673536	9.043947	852.938312
2	1041	5	996	0.000000	0.181073	1.381812	0.087608	55.359891
3	1268	287	1222	6.962825	0.019936	331.528802	250.154847	4243.938312

	Count of Visitors	Sum of Transactions Made	Count of Returning Visitors	Average Page Values	Average Exit Rates	Average Administrative_Duration	Average Informational_Duration	Average ProductRelated_Duration
4CC_2
0	1538	250	1124	6.910813	0.023658	238.192616	92.105426	698.879555
1	728	3	682	0.000000	0.198339	0.000000	0.015110	0.023123
2	9532	1581	8459	6.373509	0.034920	50.198511	28.782988	1422.055295
3	532	74	286	2.318482	0.032813	285.077097	16.947521	190.406452

	Count of Visitors	Sum of Transactions Made	Count of Returning Visitors	Average Page Values	Average Exit Rates	Average Administrative_Duration	Average Informational_Duration	Average ProductRelated_Duration
5CC
0	915	32	882	1.360801	0.050171	30.120709	9.616411	907.302773
1	7682	0	6466	1.321865	0.033996	55.122319	9.560449	848.208278
2	892	4	847	0.000000	0.188856	1.095889	0.000000	40.252108
3	1195	282	1152	7.030489	0.019867	336.109519	260.538065	4345.424080
4	1646	1590	1204	32.085915	0.019334	86.789160	19.112572	1310.094901

	Count of Visitors	Sum of Transactions Made	Count of Returning Visitors	Average Page Values	Average Exit Rates	Average Administrative_Duration	Average Informational_Duration	Average ProductRelated_Duration
5CC_2
0	1404	230	1016	6.904934	0.022771	256.671525	26.727277	712.075199
1	727	3	681	0.000000	0.198429	0.000000	0.000000	0.023155
2	9464	1570	8402	6.392799	0.035003	49.647374	28.409172	1425.782218
3	506	71	266	2.319061	0.033083	290.290851	13.119330	190.904611
4	229	34	186	5.437239	0.029903	84.614537	489.156253	616.811510

O712 Group Assignment¶

Group 4¶

Student Names:¶

Important Note:¶

Navigating across the report:¶

Part 1: Exploratory Data Analysis¶

Section 1: Loading Libraries¶

Section 2 : Importing the Data¶

Section 3 : Understanding the Basic Layout of the dataset and insights¶

Part 2: ML Models and Customer Segments¶

Section 1: Loading Libraries¶

Section 2: Loading Data¶

Section 3: Running Log Reg, KNN, and Decision Tree models to identify the best model¶

Section 4: Identifying the Business Acceptable Model¶

Section 5: Customer Segments¶

Part 3: Strategies and Conclusion¶

Part 1: Exploratory Data Analysis¶

Section 1: Loading Libraries¶

Section 2 : Importing the Data¶

Section 3 : Understanding the Basic Layout of the dataset¶

The size of the dataset¶

The dataset has 12330 records and have 13 Columns.¶

Checking Presence of Null Values¶

Checking for duplicates in the data¶

Checking if all numerical columns are within their range or not¶

Section 4 : Insights through Data Visualization¶

Let's now delve into a deeper understanding of data.¶

Lets' Observe how is the buying pattern of visitors during weekends¶

Lets Investigate How is the Visit Pattern of Visitors¶

Part 2: ML Models¶

Section 1: Loading Libraries¶

Section 2: Loading Data¶

Basic CorrPlot with HeatMap¶

Reordering the Columns¶

Section 3: Loading Essential ML Libraries¶

Section 3: Running Log Reg, KNN, and Decision Tree models to identify the best model¶

Log Reg Model (Full)¶

Splitting the Data into Training and Testing¶

Initiating the Log Reg Model¶

Fitting the FULL Data into Log Model¶

Make Predictions using the Full Scale Log Model¶

Confusion Matrix for Full Scale Log R Model¶

Accuracy = Correctly Predicted Values/All Values¶

Classification Report¶

AUC Score¶

Model Summary of Log Reg¶

KNN Model (Full)¶

Scale the Data for KNN Model¶

Create the KNN model¶

Train the model on the Xtrain¶

Make the predictions on the Xtrain and Xtest data¶

Check the Accuracy on the Xtrain and Xtest data¶

Now we will run a loop for 1-50 for a value of K=1 to K-50¶

The Model has the best test and train accuracy at Neighbour = 24 k= 24 is our Best Model.¶

Retraining the BEST KNN For Full Data¶

Accuracy Score¶

Confusion Matrix¶

Accuracy = Correctly Predicted Values/All Values¶

Classification Report¶

ROC Curve¶

Area Under the Curve¶

Model Summary of BEST N Full Scale KNN Model¶

Decision Tree (Full)¶

Create the model/ Initialize the Decision Tree Object¶

Get the Predicitions for the Training and Testing Data Set¶

Find the Accuracy score for TrainPredicitions and Test Predictions¶

Clear sense of Overfitting could be deduced from this results¶

Visualize the Tree¶

x = 4 is the best depth of the Tree trained on the All Columns¶

Visualise the BEST Depth Full Tree¶

Confusion Matrix¶

Accuracy = Correctly Predicted Values/All Values¶

Classification Report¶

Finding the Feature Importance or Significance¶

ROC Curve¶

AUC Score¶

Model Summary of Full Scale BEST Depth Decision Tree Model¶

MODEL COMPARISION Full LOGR ↔ Full KNN ↔ Full DT

LIMITATIONS OF FULL SCALED MODEL¶

Points For Improvements OR Pin-Points

	Count of Visitors	Sum of Transactions Made	Count of Returning Visitors	Average Page Values	Average Exit Rates	Average Administrative_Duration	Average Informational_Duration	Average ProductRelated_Duration
6CC
0	1099	276	1066	7.213116	0.019951	336.974094	275.931679	4529.184175
1	1896	2	1539	1.384727	0.031626	64.687274	13.379048	892.093766
2	5901	0	5030	1.465393	0.034663	56.116772	9.443190	853.779068
3	1639	1594	1199	31.840776	0.019330	87.664742	19.404694	1316.702720
4	915	32	882	1.341616	0.050186	30.280599	9.727340	908.738671
5	880	4	835	0.000000	0.189832	1.110833	0.000000	39.222477

	Count of Visitors	Sum of Transactions Made	Count of Returning Visitors	Average Page Values	Average Exit Rates	Average Administrative_Duration	Average Informational_Duration	Average ProductRelated_Duration
6CC_2
0	9461	1570	8400	6.394826	0.035007	49.593859	28.413987	1425.895109
1	127	0	119	0.000000	0.197900	0.000000	0.000000	0.000000
2	508	72	267	2.309930	0.033013	289.714214	13.067679	190.813615
3	600	3	562	0.000000	0.198540	0.000000	0.000000	0.028056
4	1405	229	1017	6.900019	0.022785	256.750478	26.736496	713.613722
5	229	34	186	5.437239	0.029903	84.614537	489.156253	616.811510